package com.atguigu.tingshu.album.service.impl;

import com.atguigu.tingshu.album.mapper.AlbumAttributeValueMapper;
import com.atguigu.tingshu.album.mapper.AlbumInfoMapper;
import com.atguigu.tingshu.album.mapper.AlbumStatMapper;
import com.atguigu.tingshu.album.mapper.TrackInfoMapper;
import com.atguigu.tingshu.album.service.AlbumAttributeValueService;
import com.atguigu.tingshu.album.service.AlbumInfoService;
import com.atguigu.tingshu.common.constant.RedisConstant;
import com.atguigu.tingshu.common.constant.SystemConstant;
import com.atguigu.tingshu.common.execption.GuiguException;
import com.atguigu.tingshu.common.rabbit.constant.MqConst;
import com.atguigu.tingshu.common.rabbit.service.RabbitService;
import com.atguigu.tingshu.model.album.AlbumAttributeValue;
import com.atguigu.tingshu.model.album.AlbumInfo;
import com.atguigu.tingshu.model.album.AlbumStat;
import com.atguigu.tingshu.model.album.TrackInfo;
import com.atguigu.tingshu.query.album.AlbumInfoQuery;
import com.atguigu.tingshu.vo.album.*;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RBloomFilter;
import org.redisson.api.RedissonClient;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;

@Slf4j
@Service
@SuppressWarnings({"all"})
public class AlbumInfoServiceImpl extends ServiceImpl<AlbumInfoMapper, AlbumInfo> implements AlbumInfoService {
    @Autowired
    private AlbumInfoMapper albumInfoMapper;
    @Autowired
    private AlbumAttributeValueMapper attributeValueMapper;
    @Autowired
    private AlbumAttributeValueService albumAttributeValueService;
    @Autowired
    private AlbumAttributeValueMapper albumAttributeValueMapper;
    @Autowired
    private AlbumStatMapper albumStatMapper;

    @Autowired
    private TrackInfoMapper trackInfoMapper;
    @Autowired
    private RabbitService rabbitService;
    @Autowired
    private RedissonClient redissonClient;

    /**
     * 保存专辑
     * @param albumInfoVo
     * @param userId
     */
    @Override
    public void saveAlbumInfo(AlbumInfoVo albumInfoVo, Long userId) {
        //	创建专辑对象
        AlbumInfo albumInfo = new AlbumInfo();
        //	属性拷贝
        BeanUtils.copyProperties(albumInfoVo, albumInfo);
        //	创建专辑的时候，应该知道是谁创建的专辑
        albumInfo.setUserId(userId);
        //	设置专辑审核状态为：通过
        albumInfo.setStatus(SystemConstant.ALBUM_STATUS_PASS);
        //  付费的默认前前5集免费试看
        if (!SystemConstant.ALBUM_PAY_TYPE_FREE.equals(albumInfoVo.getPayType())) {
            albumInfo.setSecondsForFree(5);
        }
        //	保存专辑
        albumInfoMapper.insert(albumInfo);
        //	保存专辑属性值：
        List<AlbumAttributeValueVo> albumAttributeValueVoList = albumInfoVo.getAlbumAttributeValueVoList();

        if (!CollectionUtils.isEmpty(albumAttributeValueVoList)) {
            //	流操作遍历设置字段值
            List<AlbumAttributeValue> albumAttributeValuesList = albumAttributeValueVoList.stream().map(albumAttributeValueVo -> {
                //  创建对象
                AlbumAttributeValue albumAttributeValue = new AlbumAttributeValue();
                //  属性拷贝
                BeanUtils.copyProperties(albumAttributeValueVo, albumAttributeValue);
                //  给专辑属性Id 赋值 @TableId(type = IdType.AUTO) 表示能够获取到主键自增值！
                albumAttributeValue.setAlbumId(albumInfo.getId());
                return albumAttributeValue;
            }).collect(Collectors.toList());
            //	保存数据
            albumAttributeValueService.saveBatch(albumAttributeValuesList);
        }
        //初始化统计数据
        //播放量
        this.saveAlbumStat(albumInfo.getId(), SystemConstant.ALBUM_STAT_PLAY);
        //订阅量
        this.saveAlbumStat(albumInfo.getId(), SystemConstant.ALBUM_STAT_SUBSCRIBE);
        //购买量
        this.saveAlbumStat(albumInfo.getId(), SystemConstant.ALBUM_STAT_BROWSE);
        //评论数
        this.saveAlbumStat(albumInfo.getId(), SystemConstant.ALBUM_STAT_COMMENT);

        //	发送上架消息
        if ("1".equals(albumInfo.getIsOpen())) {
            rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_ALBUM_UPPER,albumInfo.getId());
        }

    }

    /**
     * 初始化统计数据
     *
     * @param albumId
     * @param statType
     */
    private void saveAlbumStat(Long id, String albumStatPlay) {
        AlbumStat albumStat = new AlbumStat();
        albumStat.setAlbumId(id);
        albumStat.setStatType(albumStatPlay);
        albumStat.setStatNum(new Random().nextInt(10000));
        albumStatMapper.insert(albumStat);
    }

    /**
     * 分页查询用户专辑列表
     * @param albumListVoPage
     * @param albumInfoQuery
     * @return
     */

    @Override
    public IPage<AlbumListVo> findUserAlbumPage(IPage<AlbumListVo> albumListVoPage, AlbumInfoQuery albumInfoQuery) {

        IPage<AlbumListVo> albumListVo = albumInfoMapper.findUserAlbumPage(albumListVoPage, albumInfoQuery);
        return albumListVo;
    }

    /**
     * 删除专辑
     * @param id
     */
    @Override
    public void removeAlbumInfo(Long id) {
        //查询专辑下是否有声音
        Long count = trackInfoMapper.selectCount(new LambdaQueryWrapper<TrackInfo>().eq(TrackInfo::getAlbumId, id));
        if (count > 0) {
            throw new GuiguException(400, "该专辑下有声音");
        }
        //删除专辑信息
        this.albumInfoMapper.deleteById(id);
        //删除专辑属性信息
        attributeValueMapper.delete(new LambdaQueryWrapper<AlbumAttributeValue>().eq(AlbumAttributeValue::getAlbumId, id));
        //删除专辑统计信息
        albumStatMapper.delete(new LambdaQueryWrapper<AlbumStat>().eq(AlbumStat::getAlbumId, id));

        //下架发送消息
        rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_ALBUM_LOWER,id);

    }

    /**
     * 根据id查询专辑信息
     * @param id
     * @return
     */
    @Override
    public AlbumInfo getAlbumInfoById(Long albumnId) {
        //	根据id 查询专辑数据
        AlbumInfo albumInfo = this.getById(albumnId);
        //	回显时，需要回显专辑数据信息数据
        if (null != albumInfo) {
            List<AlbumAttributeValue> albumAttributeValues = attributeValueMapper.selectList(new LambdaQueryWrapper<AlbumAttributeValue>().eq(AlbumAttributeValue::getAlbumId, albumnId));
            albumInfo.setAlbumAttributeValueVoList(albumAttributeValues);
        }
        return albumInfo;
    }

    /**
     * 修改专辑信息
     * @param id
     * @param albumInfoVo
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public void updateAlbumInfo(Long id, AlbumInfoVo albumInfoVo) {
        AlbumInfo albumInfo = new AlbumInfo();
        BeanUtils.copyProperties(albumInfoVo, albumInfo);
        albumInfo.setId(id);
        //	根据id 修改数据
        this.albumInfoMapper.updateById(albumInfo);
        //	保存专辑属性数据
        List<AlbumAttributeValueVo> albumAttributeValueVoList = albumInfoVo.getAlbumAttributeValueVoList();

        List<AlbumAttributeValue> attributeValueVoList = albumAttributeValueVoList.stream().map(albumAttributeValueVo -> {

            AlbumAttributeValue albumAttributeValue1 = new AlbumAttributeValue();

            //  属性拷贝
            BeanUtils.copyProperties(albumAttributeValueVo, albumAttributeValue1);
            //  给专辑属性Id 赋值 @TableId(type = IdType.AUTO) 表示能够获取到主键自增值！
            albumAttributeValue1.setAlbumId(albumInfo.getId());
            return albumAttributeValue1;
        }).collect(Collectors.toList());

        albumAttributeValueService.saveBatch(attributeValueVoList);


        if ("1".equals(albumInfo.getIsOpen())) {
            rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_ALBUM_UPPER,albumInfo.getId());
        }else {
            rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_ALBUM_LOWER,albumInfo.getId());
        }
    }

    /**
     * 获取全部专辑列表
     * @param userId
     * @return
     */
    @Override
    public List<AlbumInfo> findUserAllAlbumList(long userId) {
        // select * from albumn_info where user_id = 1 and is_delete =0 order by id desc limit 30;
        LambdaQueryWrapper<AlbumInfo> albumInfoLambdaQueryWrapper = new LambdaQueryWrapper<>();
        albumInfoLambdaQueryWrapper.eq(AlbumInfo::getUserId,userId);
        albumInfoLambdaQueryWrapper.orderByDesc(AlbumInfo::getId).last(" limit 30");

        return albumInfoMapper.selectList(albumInfoLambdaQueryWrapper);
    }

    /**
     * 查询专辑属性集合
     * @param albumId
     * @return
     */
    @Override
    public List<AlbumAttributeValue> findAlbumAttributeValue(Long albumId) {
        List<AlbumAttributeValue> albumAttributeValueList = albumAttributeValueMapper.selectList(new LambdaQueryWrapper<AlbumAttributeValue>().eq(AlbumAttributeValue::getAlbumId, albumId));
        return albumAttributeValueList;
    }

    /**
     * 查询专辑统计数据
     * @param albumId
     * @return
     */
    @Override
    public AlbumListStartVo findAlbumStartValue(Long albumId) {

        AlbumListStartVo albumListStartVo=albumStatMapper.findAlbumStartValue(albumId);

        return albumListStartVo;
    }

    /**
     * 查询专辑统计数据
     * @param albumId
     * @return
     */
    @Override
    public AlbumStatVo getAlbumStartInfo(Long albumId) {
        AlbumStatVo albumStatInfo=albumStatMapper.getAlbumStartInfo(albumId);
        return albumStatInfo;
    }
}
